package com.event.management.backend.controller;

import cn.dev33.satoken.annotation.SaCheckLogin;
import cn.dev33.satoken.annotation.SaCheckRole;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.event.management.backend.dto.EventDTO;
import com.event.management.backend.dto.EventQueryParam;
import com.event.management.backend.service.EventService;
import com.event.management.backend.service.QuestionnaireService;
import com.event.management.backend.util.Result;
import com.event.management.backend.util.UrlUtils;
import com.mysql.cj.log.Log;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;

/**
 * 活动控制器
 */
@Api(tags = "活动管理接口")
@RestController
@RequestMapping("/api/events")
public class EventController {
    
    @Autowired
    private EventService eventService;
    
    @Autowired
    private QuestionnaireService questionnaireService;
    

    
    /**
     * 获取活动列表（分页）
     * @param queryParam 查询参数
     * @return 活动列表
     */
    @ApiOperation(value = "获取活动列表", notes = "分页查询活动列表，支持关键词搜索、状态和创建者筛选，以及按分类和标签筛选")
    @GetMapping
    @SaCheckRole(value = {"admin", "organizer"}, mode = cn.dev33.satoken.annotation.SaMode.OR)
    public Result<Map<String, Object>> getEventList(EventQueryParam queryParam) {
        IPage<EventDTO> page = eventService.getEventPage(queryParam);
        
        // 构建返回结果
        Map<String, Object> result = new HashMap<>();
        result.put("total", page.getTotal());
        result.put("pages", page.getPages());
        result.put("list", page.getRecords());
        
        // 额外添加分类数据统计
        if (Boolean.TRUE.equals(queryParam.getUseRecommendSort())) {
            result.put("sortBy", "recommend"); // 提示前端采用了推荐排序
        }
        
        return Result.success(result);
    }
    
    /**
     * 获取活动详情
     * @param id 活动ID
     * @return 活动详情
     */
    @ApiOperation(value = "获取活动详情", notes = "根据ID获取活动详细信息")
    @GetMapping("/{id}")
    @SaCheckRole(value = {"admin", "organizer"}, mode = cn.dev33.satoken.annotation.SaMode.OR)
    public Result<EventDTO> getEventDetail(
            @ApiParam(value = "活动ID", required = true) @PathVariable Long id) {
        if (id == null || id <= 0) {
            return Result.validateFailed("活动ID不合法");
        }
        
        EventDTO eventDTO = eventService.getEventById(id);
        if (eventDTO == null) {
            return Result.error(404, "活动不存在或已被删除");
        }
        
        // 增加浏览量（异步方式）
        eventService.incrementViewCount(id);
        
        return Result.success(eventDTO);
    }
    

    
    /**
     * 添加活动
     * @param eventDTO 活动信息
     * @return 添加结果
     */
    @ApiOperation(value = "添加活动", notes = "添加新活动（需要管理员或组织者权限）")
    @PostMapping
    @SaCheckRole(value = {"admin", "organizer"}, mode = cn.dev33.satoken.annotation.SaMode.OR)
    public Result<Long> addEvent(@Validated @RequestBody EventDTO eventDTO) {
        try {
            // 验证封面URL长度
            if (eventDTO.getCover() != null && eventDTO.getCover().length() > UrlUtils.MAX_URL_LENGTH) {
                // 通知前端URL被截断
                String processedUrl = UrlUtils.processUrl(eventDTO.getCover());
                eventDTO.setCover(processedUrl);
                // 可以选择添加警告信息
                // return Result.success(eventService.addEvent(eventDTO), "添加活动成功，但封面URL过长已被截断");
            }
            
            // 手动验证状态值
            if (eventDTO.getStatus() != null && !eventDTO.isValidStatus()) {
                return Result.validateFailed("活动状态只能是draft、online或offline");
            }
            
            // 处理标签字段
            if (eventDTO.getTags() != null && eventDTO.getTags().length() > 255) {
                // 简单截断提示
                return Result.validateFailed("活动标签总长度不能超过255个字符");
            }
            
            // 设置初始浏览量和推荐分数
            eventDTO.setViewCount(0);
            eventDTO.setRecommendScore(0.0f);
            
            Long eventId = eventService.addEvent(eventDTO);
            return Result.success(eventId, "添加活动成功");
        } catch (Exception e) {
            // 记录异常信息
            // logger.error("添加活动异常: " + e.getMessage(), e);
            return Result.error(500, "添加活动失败：" + e.getMessage());
        }
    }
    
    /**
     * 更新活动
     * @param id 活动ID
     * @param eventDTO 活动信息
     * @return 更新结果
     */
    @ApiOperation(value = "更新活动", notes = "更新活动信息（需要管理员或组织者权限）")
    @PutMapping("/{id}")
    @SaCheckRole(value = {"admin", "organizer"}, mode = cn.dev33.satoken.annotation.SaMode.OR)
    public Result<Boolean> updateEvent(
            @ApiParam(value = "活动ID", required = true) @PathVariable Long id,
            @Validated @RequestBody EventDTO eventDTO) {
        if (id == null || id <= 0) {
            return Result.validateFailed("活动ID不合法");
        }
        
        try {
            // 验证封面URL长度
            if (eventDTO.getCover() != null && eventDTO.getCover().length() > UrlUtils.MAX_URL_LENGTH) {
                // 通知前端URL被截断
                String processedUrl = UrlUtils.processUrl(eventDTO.getCover());
                eventDTO.setCover(processedUrl);
                // 可以选择添加警告信息
                // return Result.success(eventService.updateEvent(id, eventDTO), "更新活动成功，但封面URL过长已被截断");
            }
            
            // 手动验证状态值
            if (eventDTO.getStatus() != null && !eventDTO.isValidStatus()) {
                return Result.validateFailed("活动状态只能是draft、online或offline");
            }
            
            boolean success = eventService.updateEvent(id, eventDTO);
            if (!success) {
                return Result.error(404, "活动不存在或已被删除");
            }
            return Result.success(success, "更新活动成功");
        } catch (Exception e) {
            // 记录异常信息
            // logger.error("更新活动异常: " + e.getMessage(), e);
            return Result.error(500, "更新活动失败：" + e.getMessage());
        }
    }
    
    /**
     * 删除活动
     * @param id 活动ID
     * @return 删除结果
     */
    @ApiOperation(value = "删除活动", notes = "删除活动（需要管理员或组织者权限）")
    @DeleteMapping("/{id}")
    @SaCheckRole(value = {"admin", "organizer"}, mode = cn.dev33.satoken.annotation.SaMode.OR)
    public Result<Boolean> deleteEvent(
            @ApiParam(value = "活动ID", required = true) @PathVariable Long id) {
        boolean success = eventService.deleteEvent(id);
        return Result.success(success, "删除活动成功");
    }
    
    /**
     * 关联多个问卷模板到活动
     * @param id 活动ID
     * @param templateIds 问卷模板ID列表
     * @return 关联结果
     */
    @ApiOperation(value = "关联多个问卷", notes = "将多个问卷模板关联到指定活动（需要管理员或活动创建者权限）")
    @PostMapping("/{id}/questionnaires")
    @SaCheckRole(value = {"admin", "organizer"}, mode = cn.dev33.satoken.annotation.SaMode.OR)
    public Result<Map<String, Object>> associateQuestionnaires(
            @ApiParam(value = "活动ID", required = true) @PathVariable Long id,
            @ApiParam(value = "问卷模板ID列表", required = true) @RequestBody List<Long> templateIds) {
        if (id == null || id <= 0) {
            return Result.validateFailed("活动ID不合法");
        }
        
        if (templateIds == null || templateIds.isEmpty()) {
            return Result.validateFailed("问卷模板ID列表不能为空");
        }
        
        try {
            // 记录请求信息，便于调试
            System.out.println("关联问卷模板请求 - 活动ID: " + id + ", 模板IDs: " + templateIds);
            
            // 检查是否有权限管理此活动
            if (!eventService.checkEventManagePermission(id)) {
                return Result.error(403, "您没有权限管理此活动");
            }
            
            // 记录关联结果
            Map<Long, Boolean> results = new HashMap<>();
            int successCount = 0;
            
            // 逐个关联问卷模板
            for (Long templateId : templateIds) {
                try {
                    System.out.println("正在关联模板ID: " + templateId + " 到活动ID: " + id);
                    boolean success = questionnaireService.associateToEvent(id, templateId);
                    results.put(templateId, success);
                    if (success) {
                        successCount++;
                        System.out.println("模板ID: " + templateId + " 关联成功");
                    } else {
                        System.out.println("模板ID: " + templateId + " 关联失败");
                    }
                } catch (Exception e) {
                    // 单个关联失败不影响整体流程
                    System.err.println("模板ID: " + templateId + " 关联异常: " + e.getMessage());
                    e.printStackTrace();
                    results.put(templateId, false);
                }
            }
            
            // 构建返回结果
            Map<String, Object> result = new HashMap<>();
            result.put("totalCount", templateIds.size());
            result.put("successCount", successCount);
            result.put("details", results);
            
            return Result.success(result, "关联问卷模板完成");
        } catch (Exception e) {
            e.printStackTrace();
            return Result.error(500, "关联问卷模板失败：" + e.getMessage());
        }
    }
    
    /**
     * 获取文件扩展名
     * @param filename 原始文件名
     * @return 扩展名（包含点号）
     */
    private String getFileExtension(String filename) {
        if (filename == null || filename.isEmpty()) {
            return ".jpg"; // 默认扩展名
        }
        int dotIndex = filename.lastIndexOf('.');
        if (dotIndex < 0) {
            return ".jpg"; // 如果没有扩展名，返回默认扩展名
        }
        return filename.substring(dotIndex);
    }
} 